import java.io.IOException;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.nio.charset.StandardCharsets;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.HashMap;
import com.sun.net.httpserver.HttpHandler;
import com.sun.net.httpserver.HttpExchange;

public class BookServer {
    private static com.sun.net.httpserver.HttpServer server;
    private static Connection connection;

    public static void main(String[] args) throws IOException {
        System.out.println("开始初始化数据库...");
        initializeDatabase();
        System.out.println("数据库初始化完成。");

        try {
            server = com.sun.net.httpserver.HttpServer.create(new InetSocketAddress(6666), 0);
            System.out.println("HTTP 服务器创建于端口 6666。");
        } catch (IOException e) {
            System.out.println("创建 HTTP 服务器失败: " + e.getMessage());
            throw e;
        }

        server.createContext("/login", new LoginHandler());
        server.createContext("/register", new RegisterHandler());
        server.createContext("/books", new BooksHandler());
        server.createContext("/book_detail", new BookDetailHandler());
        server.createContext("/borrow_records", new BorrowRecordsHandler());
        server.createContext("/personal_info", new PersonalInfoHandler());
        server.createContext("/update_status", new UpdateStatusHandler());
        server.createContext("/add_book", new AddBookHandler());
        server.createContext("/book_content", new BookContentHandler());

        server.start();
        System.out.println("服务器已启动，运行于端口 6666");
    }

    private static void initializeDatabase() {
        try {
            System.out.println("加载 SQLite JDBC 驱动...");
            Class.forName("org.sqlite.JDBC");
            System.out.println("SQLite JDBC 驱动加载成功。");

            System.out.println("连接到数据库...");
            connection = DriverManager.getConnection("jdbc:sqlite:library.db");
            System.out.println("数据库连接成功。");

            Statement stmt = connection.createStatement();

            System.out.println("创建 'users' 表（如果不存在）...");
            stmt.executeUpdate("CREATE TABLE IF NOT EXISTS users (" +
                    "username TEXT PRIMARY KEY, " +
                    "password TEXT NOT NULL)");
            System.out.println("'users' 表创建成功或已存在。");

            System.out.println("创建 'books' 表（如果不存在）...");
            stmt.executeUpdate("CREATE TABLE IF NOT EXISTS books (" +
                    "id INTEGER PRIMARY KEY, " +
                    "title TEXT NOT NULL, " +
                    "author TEXT NOT NULL, " +
                    "category TEXT NOT NULL, " +
                    "publishDate TEXT NOT NULL, " +
                    "status TEXT NOT NULL, " +
                    "coverResId TEXT NOT NULL, " +
                    "description TEXT, " +
                    "isbn TEXT, " +
                    "publisher TEXT, " +
                    "pageCount INTEGER, " +
                    "backgroundStory TEXT, " +
                    "content TEXT)");
            System.out.println("'books' 表创建成功或已存在。");

            System.out.println("创建 'borrow_records' 表（如果不存在）...");
            stmt.executeUpdate("CREATE TABLE IF NOT EXISTS borrow_records (" +
                    "id INTEGER PRIMARY KEY AUTOINCREMENT, " +
                    "username TEXT NOT NULL, " +
                    "book_title TEXT NOT NULL, " +
                    "borrow_date TEXT NOT NULL)");
            System.out.println("'borrow_records' 表创建成功或已存在。");

            System.out.println("创建 'personal_info' 表（如果不存在）...");
            stmt.executeUpdate("CREATE TABLE IF NOT EXISTS personal_info (" +
                    "username TEXT PRIMARY KEY, " +
                    "studentId TEXT NOT NULL, " +
                    "borrowedCount INTEGER NOT NULL, " +
                    "borrowing TEXT NOT NULL)");
            System.out.println("'personal_info' 表创建成功或已存在。");

            initializeTestData();
        } catch (Exception e) {
            System.err.println("数据库初始化失败: " + e.getMessage());
            System.exit(1);
        }
    }

    private static void initializeTestData() throws SQLException {
        System.out.println("检查是否需要初始化测试数据...");
        Statement stmt = connection.createStatement();
        ResultSet rs = stmt.executeQuery("SELECT COUNT(*) FROM books");
        if (rs.getInt(1) == 0) {
            System.out.println("初始化测试数据...");

            String androidBookContent = 
                "第一章 Android基础\n" +
                "Android是一个基于Linux的开源操作系统，由Google公司开发和维护。Android系统最初设计用于触摸屏移动设备，如智能手机和平板电脑，但后来也扩展到其他设备，如电视、汽车、可穿戴设备和物联网设备。\n\n" +
                "Android系统的架构分为多个层次，包括Linux内核、原生库、Android运行时、应用程序框架和应用程序。Linux内核负责设备的底层硬件管理，原生库提供了核心功能，如图形渲染和数据存储，Android运行时包括ART（Android RunTime）和核心Java库，应用程序框架提供了开发应用所需的API，而应用程序则是用户直接交互的界面。\n\n" +
                "Android应用开发主要使用Java和Kotlin语言，Kotlin是Google官方推荐的Android开发语言，具有简洁、安全和互操作性强的特点。开发Android应用需要使用Android Studio，这是Google提供的官方集成开发环境（IDE），基于IntelliJ IDEA构建，提供了丰富的工具和插件，支持代码编辑、调试、性能分析等功能。\n\n" +
                "Android应用的基本组件包括活动（Activity）、服务（Service）、广播接收器（BroadcastReceiver）和内容提供器（ContentProvider）。活动是用户与应用交互的界面，服务在后台运行以执行长时间的操作，广播接收器允许应用接收和响应系统或应用广播的事件，内容提供器用于在不同应用之间共享数据。\n\n" +
                "Android应用的用户界面通常使用XML布局文件定义，支持多种布局类型，如线性布局（LinearLayout）、相对布局（RelativeLayout）、约束布局（ConstraintLayout）等。开发者可以使用XML标签定义视图组件，如文本视图（TextView）、按钮（Button）、图像视图（ImageView）等，并在Java或Kotlin代码中动态操控这些组件。\n\n" +
                "Android系统支持多种数据存储方式，包括SharedPreferences、SQLite数据库、文件存储和网络存储。SharedPreferences适用于存储简单的键值对数据，SQLite数据库适用于结构化数据存储，文件存储用于保存文件（如图片、文档等），网络存储则通过网络请求将数据存储在远程服务器上。\n\n" +
                "Android应用的生命周期管理是开发中的重要部分，活动、服务等组件都有各自的生命周期回调方法，如活动的onCreate()、onStart()、onResume()、onPause()、onStop()、onDestroy()等。正确管理生命周期可以提高应用的性能和稳定性，避免内存泄漏和资源浪费。\n\n" +
                "随着Android系统的不断更新，Google引入了许多新特性和功能，如Jetpack组件、Compose UI框架、机器学习套件（ML Kit）、增强现实（AR）支持等，帮助开发者更高效地构建现代化的Android应用。\n\n" +
                "第二章 Android应用开发流程\n" +
                "开发Android应用需要遵循一定的流程，包括项目创建、界面设计、逻辑实现、调试测试和应用发布。\n\n" +
                "首先，使用Android Studio创建一个新项目，选择合适的模板和配置，如最小SDK版本、应用包名等。然后，设计应用的用户界面，通常在res/layout目录下创建XML布局文件，定义活动、片段（Fragment）等组件的界面。接着，实现应用的逻辑功能，在Java或Kotlin代码中处理用户交互、数据操作、网络请求等任务。在开发过程中，不断进行调试和测试，使用Android Studio的调试工具、模拟器（Emulator）或真实设备，修复发现的bug和问题。最后，当应用开发完成并经过充分测试后，可以将其打包为APK或AAB文件，发布到Google Play商店或其他应用分发平台。";

            String javaBookContent = 
                "第一章 Java基础\n" +
                "Java是一种高级的、面向对象的编程语言，由Sun Microsystems公司于1995年发布，现由Oracle公司拥有和维护。Java语言的设计目标是简单、健壮、安全、跨平台，适用于各种应用场景，从桌面应用到服务器端应用，再到移动设备和嵌入式系统。\n\n" +
                "Java语言具有许多特点，如面向对象、平台无关性、自动内存管理、异常处理、多线程支持等。面向对象的特性使得Java代码具有良好的结构和可维护性，平台无关性通过Java虚拟机（JVM）实现，使得Java程序可以在不同操作系统上运行，自动内存管理通过垃圾回收机制减轻了开发者的负担，异常处理提供了统一的错误处理机制，而多线程支持则使得Java适合开发并发应用。\n\n" +
                "Java开发环境主要包括Java开发工具包（JDK）、集成开发环境（IDE）如Eclipse、IntelliJ IDEA、NetBeans等。JDK包含了Java编译器（javac）、Java运行时环境（JRE）、标准类库等工具，IDE则提供了代码编辑、调试、项目管理等功能，帮助开发者更高效地编写和管理Java代码。\n\n" +
                "Java编程的基本单位是类和对象，类是对象的蓝图，定义了对象的属性和行为，对象是类的实例。Java中的类通过继承机制可以形成层次结构，子类可以继承父类的属性和方法，并可以添加新的属性和方法或重写父类的方法。接口在Java中定义了一组方法的签名，类可以通过实现接口来承诺提供这些方法的实现，接口支持多重继承，弥补了Java类只能单继承的限制。\n\n" +
                "Java中的数据类型分为基本类型和引用类型，基本类型包括整数类型（如int、long）、浮点类型（如float、double）、字符类型（char）、布尔类型（boolean），引用类型包括类、接口、数组等。Java中的变量必须先声明后使用，方法是类中定义的功能单元，可以接受参数并返回值，Java中的方法调用是通过对象进行的。\n\n" +
                "Java中的包用于组织类和接口，避免命名冲突，通过import语句可以引入其他包中的类。Java中的访问控制修饰符包括public、protected、default、private，用于控制类、方法、变量的可见性。Java中的异常处理通过try-catch-finally语句实现，可以捕获和处理运行时异常，确保程序的健壮性。\n\n" +
                "Java的标准类库提供了丰富的API，涵盖了从基本数据结构（如集合框架）到网络编程、文件操作、数据库访问、图形用户界面（GUI）开发等各个方面的功能。Java的集合框架提供了多种数据结构的实现，如列表（List）、集合（Set）、映射（Map）等，方便开发者高效地处理数据。Java的数据库访问通过JDBC（Java Database Connectivity）API实现，可以连接和操作各种关系型数据库。\n\n" +
                "随着Java技术的不断发展，Java社区和生态系统也日益丰富，包括各种开源框架（如Spring、Hibernate）、工具（如Maven、Gradle）、库（如Google Guava、Apache Commons）等，这些资源可以帮助开发者更高效地构建各种类型的应用。";

            String dataStructureContent = 
                "第一章 数据结构概述\n" +
                "数据结构是计算机科学中的一个重要概念，它研究数据的组织、存储和操作方式。数据结构的选择和设计直接影响到算法的效率和程序的性能。常见的数据结构包括数组、链表、栈、队列、树、图等，每种数据结构都有其特定的特性和适用场景。\n\n" +
                "数组是最基本的数据结构之一，它是由固定大小的元素序列组成，每个元素可以通过索引直接访问，具有快速的随机访问能力，但插入和删除操作通常需要移动大量元素。链表则由一系列节点组成，每个节点包含数据和指向下一个节点的指针，链表的插入和删除操作较为灵活，但访问元素需要从头开始遍历，速度相对较慢。\n\n" +
                "栈是一种后进先出（LIFO）的数据结构，它支持两种主要操作：push（将元素压入栈顶）和pop（从栈顶弹出元素）。栈常用于函数调用的管理、递归实现、表达式求值等场景。队列是一种先进先出（FIFO）的数据结构，支持enqueue（在队尾添加元素）和dequeue（在队首移除元素）操作，队列常用于任务调度、缓冲区管理、模拟现实世界的排队系统等。\n\n" +
                "树是一种分层的非线性数据结构，由节点组成，每个节点可以有零个或多个子节点，但有且只有一个父节点（根节点除外）。二叉树是树的一种特殊形式，每个节点最多有两个子节点，二叉搜索树（BST）是一种特殊的二叉树，其左子树上的所有节点的值小于根节点的值，右子树上的所有节点的值大于根节点的值，这使得二叉搜索树具有高效的查找、插入和删除性能。平衡二叉树（如AVL树、红黑树）通过旋转等操作保持树的高度平衡，确保操作的对数时间复杂度。\n\n" +
                "图是一种由节点（顶点）和边组成的复杂数据结构，用于表示对象之间的多对多关系。图可以分为有向图和无向图，边可以有权重（加权图）或无权重（非加权图）。图的遍历算法包括深度优先搜索（DFS）和广度优先搜索（BFS），用于访问图中的所有顶点。图的应用非常广泛，如社交网络分析、地图导航、网络路由算法等。\n\n" +
                "哈希表是一种基于哈希函数的数据结构，它通过计算键的哈希值来确定值的存储位置，提供了快速的插入和查找操作。哈希表的性能取决于哈希函数的质量和解决哈希冲突的方法（如链地址法、开放地址法）。哈希表常用于实现关联数组、数据库索引、缓存等。\n\n" +
                "算法是数据结构的灵魂，常见的算法包括排序算法（如冒泡排序、快速排序、归并排序）、查找算法（如顺序查找、二分查找）、图算法（如Dijkstra最短路径算法、Kruskal最小生成树算法）等。算法的效率通常用时间复杂度和空间复杂度来衡量，选择合适的数据结构和算法可以显著提高程序的性能和可扩展性。\n\n" +
                "在实际应用中，选择合适的数据结构需要考虑数据的特点、操作的频率、性能要求等因素。例如，如果需要频繁地插入和删除元素，链表可能比数组更合适；如果需要快速的随机访问，数组则是更好的选择。理解各种数据结构的原理和应用场景，有助于编写高效、可靠的软件系统。";

            stmt.executeUpdate("INSERT INTO books VALUES " +
                    "(1, 'Android编程指南', '张三', '计算机', '2023-01-01', 'Available', 'book_android', " +
                    "'一本全面的Android开发指南', '978-3-16-148410-0', '科技出版社', 500, " +
                    "'本书由资深Android开发工程师张三历时两年编写完成...', " +
                    "'" + androidBookContent + "'), " +

                    "(2, 'Java入门教程', '李四', '计算机', '2022-05-15', 'Borrowed', 'book_java', " +
                    "'从零开始学习Java编程', '978-1-23-456789-0', '编程之家出版社', 350, " +
                    "'作者李四根据自己10年Java教学经验编写...', " +
                    "'" + javaBookContent + "'), " +

                    "(3, '数据结构与算法', '王五', '计算机', '2021-11-20', 'Available', 'book_data', " +
                    "'计算机科学基础数据结构与经典算法', '978-0-12-345678-9', '算法出版社', 450, " +
                    "'这本经典教材由清华大学计算机系王五教授编写...', " +
                    "'" + dataStructureContent + "')");

            stmt.executeUpdate("INSERT INTO users VALUES " +
                    "('user1', 'password123'), " +
                    "('user2', 'password456')");

            stmt.executeUpdate("INSERT INTO borrow_records VALUES " +
                    "(NULL, 'user1', 'Java入门教程', '2023-10-01'), " +
                    "(NULL, 'user2', '数据结构与算法', '2023-09-15')");

            stmt.executeUpdate("INSERT INTO personal_info VALUES " +
                    "('user1', '20230001', 2, 'Java入门教程,数据结构与算法'), " +
                    "('user2', '20230002', 1, '数据结构与算法')");
            System.out.println("测试数据初始化成功。");
        } else {
            System.out.println("测试数据已存在，无需重复初始化。");
        }
    }

    static class Book {
        int id;
        String title;
        String author;
        String category;
        String publishDate;
        String status;
        String coverResId;
        String description;
        String isbn;
        String publisher;
        int pageCount;
        String backgroundStory;
        String content;

        public Book(int id, String title, String author, String category,
                    String publishDate, String status, String coverResId,
                    String description, String isbn, String publisher,
                    int pageCount, String backgroundStory, String content) {
            this.id = id;
            this.title = title;
            this.author = author;
            this.category = category;
            this.publishDate = publishDate;
            this.status = status;
            this.coverResId = coverResId;
            this.description = description;
            this.isbn = isbn;
            this.publisher = publisher;
            this.pageCount = pageCount;
            this.backgroundStory = backgroundStory != null ? backgroundStory : "";
            this.content = content != null ? content : "";
        }

        public String toJson() {
            return String.format(
                    "{\"id\":%d,\"title\":\"%s\",\"author\":\"%s\",\"category\":\"%s\"," +
                            "\"publishDate\":\"%s\",\"status\":\"%s\",\"coverResId\":\"%s\"," +
                            "\"description\":\"%s\",\"isbn\":\"%s\",\"publisher\":\"%s\"," +
                            "\"pageCount\":%d,\"backgroundStory\":\"%s\",\"content\":\"%s\"}",
                    id, title, author, category, publishDate, status, coverResId,
                    description != null ? description.replace("\"", "\\\"") : "",
                    isbn != null ? isbn : "",
                    publisher != null ? publisher : "",
                    pageCount,
                    backgroundStory != null ? backgroundStory.replace("\"", "\\\"") : "",
                    content != null ? content.replace("\"", "\\\"") : "");
        }
    }

    static class LoginHandler implements HttpHandler {
        @Override
        public void handle(HttpExchange exchange) throws IOException {
            System.out.println("收到登录请求。");
            Map<String, String> params = queryToMap(exchange.getRequestURI().getQuery());
            String username = params.get("username");
            String password = params.get("password");

            try {
                System.out.println("执行登录查询，用户: " + username);
                PreparedStatement stmt = connection.prepareStatement(
                        "SELECT * FROM users WHERE username = ? AND password = ?");
                stmt.setString(1, username);
                stmt.setString(2, password);
                ResultSet rs = stmt.executeQuery();

                boolean success = rs.next();
                System.out.println("用户 " + username + " 登录" + (success ? "成功" : "失败"));
                sendResponse(exchange, String.format("{\"success\":%b}", success));
            } catch (SQLException e) {
                System.out.println("用户 " + username + " 登录时发生数据库错误: " + e.getMessage());
                sendResponse(exchange, "{\"success\":false,\"error\":\"数据库错误\"}");
            }
        }
    }

    static class RegisterHandler implements HttpHandler {
        @Override
        public void handle(HttpExchange exchange) throws IOException {
            System.out.println("收到注册请求。");
            Map<String, String> params = queryToMap(exchange.getRequestURI().getQuery());
            String username = params.get("username");
            String password = params.get("password");

            try {
                System.out.println("检查用户名 " + username + " 是否已存在。");
                PreparedStatement checkStmt = connection.prepareStatement(
                        "SELECT * FROM users WHERE username = ?");
                checkStmt.setString(1, username);
                if (checkStmt.executeQuery().next()) {
                    System.out.println("用户名 " + username + " 已存在。");
                    sendResponse(exchange, "{\"success\":false,\"error\":\"用户名已存在\"}");
                    return;
                }

                System.out.println("将新用户 " + username + " 插入 'users' 表。");
                PreparedStatement insertStmt = connection.prepareStatement(
                        "INSERT INTO users VALUES (?, ?)");
                insertStmt.setString(1, username);
                insertStmt.setString(2, password);
                insertStmt.executeUpdate();

                System.out.println("为用户 " + username + " 插入个人信息到 'personal_info' 表。");
                PreparedStatement infoStmt = connection.prepareStatement(
                        "INSERT INTO personal_info VALUES (?, ?, ?, ?)");
                infoStmt.setString(1, username);
                infoStmt.setString(2, "2023" + (int) (Math.random() * 10000));
                infoStmt.setInt(3, 0);
                infoStmt.setString(4, "");
                infoStmt.executeUpdate();

                System.out.println("用户 " + username + " 注册成功。");
                sendResponse(exchange, "{\"success\":true}");
            } catch (SQLException e) {
                System.out.println("用户 " + username + " 注册失败: " + e.getMessage());
                sendResponse(exchange, "{\"success\":false,\"error\":\"注册失败\"}");
            }
        }
    }

    static class BooksHandler implements HttpHandler {
        @Override
        public void handle(HttpExchange exchange) throws IOException {
            System.out.println("收到请求所有书籍。");
            try {
                System.out.println("执行查询以检索所有书籍。");
                Statement stmt = connection.createStatement();
                ResultSet rs = stmt.executeQuery("SELECT * FROM books");

                List<Book> books = new ArrayList<>();
                while (rs.next()) {
                    books.add(new Book(
                            rs.getInt("id"),
                            rs.getString("title"),
                            rs.getString("author"),
                            rs.getString("category"),
                            rs.getString("publishDate"),
                            rs.getString("status"),
                            rs.getString("coverResId"),
                            rs.getString("description"),
                            rs.getString("isbn"),
                            rs.getString("publisher"),
                            rs.getInt("pageCount"),
                            rs.getString("backgroundStory"),
                            rs.getString("content")
                    ));
                }

                StringBuilder response = new StringBuilder("[");
                for (int i = 0; i < books.size(); i++) {
                    if (i > 0) response.append(",");
                    response.append(books.get(i).toJson());
                }
                response.append("]");

                System.out.println("成功检索到 " + books.size() + " 本书籍。");
                sendResponse(exchange, response.toString());
            } catch (SQLException e) {
                System.out.println("检索书籍时发生数据库错误: " + e.getMessage());
                sendResponse(exchange, "[]");
                e.printStackTrace();
            }
        }
    }

    static class BookDetailHandler implements HttpHandler {
        @Override
        public void handle(HttpExchange exchange) throws IOException {
            System.out.println("收到请求书籍详情。");
            Map<String, String> params = queryToMap(exchange.getRequestURI().getQuery());
            String bookId = params.get("id");

            if (bookId == null) {
                System.out.println("请求中缺少书籍ID。");
                sendResponse(exchange, "{\"error\":\"需要书籍ID\"}");
                return;
            }

            try {
                System.out.println("执行查询以检索ID为 " + bookId + " 的书籍详情");
                PreparedStatement stmt = connection.prepareStatement(
                        "SELECT * FROM books WHERE id = ?");
                stmt.setInt(1, Integer.parseInt(bookId));
                ResultSet rs = stmt.executeQuery();

                if (rs.next()) {
                    Book book = new Book(
                            rs.getInt("id"),
                            rs.getString("title"),
                            rs.getString("author"),
                            rs.getString("category"),
                            rs.getString("publishDate"),
                            rs.getString("status"),
                            rs.getString("coverResId"),
                            rs.getString("description"),
                            rs.getString("isbn"),
                            rs.getString("publisher"),
                            rs.getInt("pageCount"),
                            rs.getString("backgroundStory"),
                            rs.getString("content")
                    );
                    System.out.println("成功检索到ID为 " + bookId + " 的书籍详情");
                    sendResponse(exchange, book.toJson());
                } else {
                    System.out.println("未找到ID为 " + bookId + " 的书籍");
                    sendResponse(exchange, "{\"error\":\"未找到书籍\"}");
                }
            } catch (SQLException e) {
                System.out.println("检索ID为 " + bookId + " 的书籍详情时发生数据库错误: " + e.getMessage());
                sendResponse(exchange, "{\"error\":\"数据库错误\"}");
            }
        }
    }

    static class BorrowRecordsHandler implements HttpHandler {
        @Override
        public void handle(HttpExchange exchange) throws IOException {
            System.out.println("收到请求借阅记录。");
            try {
                System.out.println("执行查询以检索所有借阅记录。");
                Statement stmt = connection.createStatement();
                ResultSet rs = stmt.executeQuery("SELECT * FROM borrow_records");

                StringBuilder response = new StringBuilder("[");
                boolean first = true;
                while (rs.next()) {
                    if (!first) response.append(",");
                    first = false;
                    response.append(String.format(
                            "\"%s - %s - %s\"",
                            rs.getString("username"),
                            rs.getString("book_title"),
                            rs.getString("borrow_date")
                    ));
                }
                response.append("]");

                System.out.println("成功检索到借阅记录。");
                sendResponse(exchange, response.toString());
            } catch (SQLException e) {
                System.out.println("检索借阅记录时发生数据库错误: " + e.getMessage());
                sendResponse(exchange, "{\"error\":\"数据库错误\"}");
            }
        }
    }

    static class PersonalInfoHandler implements HttpHandler {
        @Override
        public void handle(HttpExchange exchange) throws IOException {
            System.out.println("收到请求个人信息。");
            Map<String, String> params = queryToMap(exchange.getRequestURI().getQuery());
            String username = params.get("username");

            try {
                System.out.println("执行查询以检索用户 " + username + " 的个人信息");
                PreparedStatement stmt = connection.prepareStatement(
                        "SELECT * FROM personal_info WHERE username = ?");
                stmt.setString(1, username);
                ResultSet rs = stmt.executeQuery();

                if (rs.next()) {
                    StringBuilder response = new StringBuilder("{");
                    response.append("\"username\":\"").append(rs.getString("username")).append("\",");
                    response.append("\"studentId\":\"").append(rs.getString("studentId")).append("\",");
                    response.append("\"borrowedCount\":").append(rs.getInt("borrowedCount")).append(",");
                    response.append("\"borrowing\":\"").append(rs.getString("borrowing")).append("\"");
                    response.append("}");

                    System.out.println("成功检索到用户 " + username + " 的个人信息");
                    sendResponse(exchange, response.toString());
                } else {
                    System.out.println("未找到用户: " + username);
                    sendResponse(exchange, "{\"error\":\"用户未找到\"}");
                }
            } catch (SQLException e) {
                System.out.println("检索用户 " + username + " 的个人信息时发生数据库错误: " + e.getMessage());
                sendResponse(exchange, "{\"error\":\"数据库错误\"}");
            }
        }
    }

    static class UpdateStatusHandler implements HttpHandler {
        @Override
        public void handle(HttpExchange exchange) throws IOException {
            System.out.println("收到更新书籍状态的请求。");
            Map<String, String> params = queryToMap(exchange.getRequestURI().getQuery());
            int bookId = Integer.parseInt(params.get("id"));
            String newStatus = params.get("status");
            String username = params.get("username");

            try {
                connection.setAutoCommit(false);
                System.out.println("更新ID为 " + bookId + " 的书籍状态为 " + newStatus);
                PreparedStatement updateBookStmt = connection.prepareStatement(
                        "UPDATE books SET status = ? WHERE id = ?");
                updateBookStmt.setString(1, newStatus);
                updateBookStmt.setInt(2, bookId);
                int rows = updateBookStmt.executeUpdate();

                if (rows > 0 && "Borrowed".equals(newStatus)) {
                    System.out.println("书籍状态更新成功。添加借阅记录并更新用户信息。");
                    PreparedStatement getBookStmt = connection.prepareStatement(
                            "SELECT title FROM books WHERE id = ?");
                    getBookStmt.setInt(1, bookId);
                    ResultSet rs = getBookStmt.executeQuery();

                    if (rs.next()) {
                        String bookTitle = rs.getString("title");

                        System.out.println("为用户 " + username + " 和书籍 " + bookTitle + " 添加借阅记录");
                        PreparedStatement addRecordStmt = connection.prepareStatement(
                                "INSERT INTO borrow_records (username, book_title, borrow_date) VALUES (?, ?, ?)");
                        addRecordStmt.setString(1, username);
                        addRecordStmt.setString(2, bookTitle);
                        addRecordStmt.setString(3, new java.text.SimpleDateFormat("yyyy-MM-dd").format(new java.util.Date()));
                        addRecordStmt.executeUpdate();

                        System.out.println("更新用户 " + username + " 的个人信息");
                        PreparedStatement updateUserStmt = connection.prepareStatement(
                                "UPDATE personal_info SET borrowedCount = borrowedCount + 1, borrowing = " +
                                        "CASE WHEN borrowing = '' THEN ? ELSE borrowing || ',' || ? END " +
                                        "WHERE username = ?");
                        updateUserStmt.setString(1, bookTitle);
                        updateUserStmt.setString(2, bookTitle);
                        updateUserStmt.setString(3, username);
                        updateUserStmt.executeUpdate();
                    }
                }

                connection.commit();
                System.out.println("书籍状态更新及相关操作成功完成。");
                sendResponse(exchange, "{\"success\":true}");
            } catch (SQLException e) {
                try {
                    connection.rollback();
                } catch (SQLException ex) {
                    ex.printStackTrace();
                }
                System.out.println("更新书籍状态时发生数据库错误: " + e.getMessage());
                sendResponse(exchange, "{\"success\":false,\"error\":\"数据库错误\"}");
            } finally {
                try {
                    connection.setAutoCommit(true);
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    static class AddBookHandler implements HttpHandler {
        @Override
        public void handle(HttpExchange exchange) throws IOException {
            System.out.println("收到添加新书的请求。");
            Map<String, String> params = queryToMap(exchange.getRequestURI().getQuery());
            String title = params.get("title");
            String author = params.get("author");
            String category = params.get("category");
            String publishDate = params.get("publishDate");
            String description = params.get("description");
            String isbn = params.get("isbn");
            String publisher = params.get("publisher");
            String pageCountStr = params.get("pageCount");
            String backgroundStory = params.get("backgroundStory");
            String content = params.get("content");

            if (title == null || author == null || category == null || publishDate == null) {
                System.out.println("添加新书的请求中缺少参数。");
                sendResponse(exchange, "{\"success\":false,\"error\":\"缺少参数\"}");
                return;
            }

            try {
                System.out.println("插入标题为 " + title + " 的新书");
                PreparedStatement stmt = connection.prepareStatement(
                        "INSERT INTO books (title, author, category, publishDate, status, coverResId, " +
                                "description, isbn, publisher, pageCount, backgroundStory, content) " +
                                "VALUES (?, ?, ?, ?, 'Available', 'book_default', ?, ?, ?, ?, ?, ?)");

                stmt.setString(1, title);
                stmt.setString(2, author);
                stmt.setString(3, category);
                stmt.setString(4, publishDate);
                stmt.setString(5, description != null ? description : "");
                stmt.setString(6, isbn != null ? isbn : "");
                stmt.setString(7, publisher != null ? publisher : "");
                stmt.setInt(8, pageCountStr != null ? Integer.parseInt(pageCountStr) : 0);
                stmt.setString(9, backgroundStory != null ? backgroundStory : "");
                stmt.setString(10, content != null ? content : "");

                int rows = stmt.executeUpdate();

                if (rows > 0) {
                    System.out.println("新书添加成功。");
                    sendResponse(exchange, "{\"success\":true}");
                } else {
                    System.out.println("添加新书时没有影响到任何行。");
                    sendResponse(exchange, "{\"success\":false,\"error\":\"未影响任何行\"}");
                }
            } catch (SQLException e) {
                System.out.println("添加新书时发生数据库错误: " + e.getMessage());
                sendResponse(exchange, "{\"success\":false,\"error\":\"数据库错误: " + e.getMessage() + "\"}");
            } catch (NumberFormatException e) {
                System.out.println("添加新书时页码必须为数字。");
                sendResponse(exchange, "{\"success\":false,\"error\":\"页码必须为数字\"}");
            }
        }
    }

    static class BookContentHandler implements HttpHandler {
        @Override
        public void handle(HttpExchange exchange) throws IOException {
            System.out.println("收到请求书籍内容。");
            Map<String, String> params = queryToMap(exchange.getRequestURI().getQuery());
            String bookId = params.get("id");

            if (bookId == null) {
                System.out.println("请求书籍内容时缺少书籍ID。");
                sendResponse(exchange, "{\"error\":\"需要书籍ID\"}");
                return;
            }

            try {
                System.out.println("执行查询以检索ID为 " + bookId + " 的书籍内容");
                PreparedStatement stmt = connection.prepareStatement(
                        "SELECT content FROM books WHERE id = ?");
                stmt.setInt(1, Integer.parseInt(bookId));
                ResultSet rs = stmt.executeQuery();

                if (rs.next()) {
                    String content = rs.getString("content");
                    System.out.println("成功检索到ID为 " + bookId + " 的书籍内容");
                    sendResponse(exchange, "{\"content\":\"" +
                            content.replace("\"", "\\\"") + "\"}");
                } else {
                    System.out.println("未找到ID为 " + bookId + " 的书籍");
                    sendResponse(exchange, "{\"error\":\"未找到书籍\"}");
                }
            } catch (SQLException e) {
                System.out.println("检索ID为 " + bookId + " 的书籍内容时发生数据库错误: " + e.getMessage());
                sendResponse(exchange, "{\"error\":\"数据库错误\"}");
            }
        }
    }

    private static void sendResponse(HttpExchange exchange, String response) throws IOException {
        exchange.getResponseHeaders().set("Content-Type", "application/json");
        exchange.getResponseHeaders().set("Access-Control-Allow-Origin", "*");
        exchange.sendResponseHeaders(200, response.getBytes(StandardCharsets.UTF_8).length);

        try (OutputStream os = exchange.getResponseBody()) {
            os.write(response.getBytes(StandardCharsets.UTF_8));
        }
    }

    private static Map<String, String> queryToMap(String query) {
        Map<String, String> result = new HashMap<>();
        if (query == null) return result;

        for (String param : query.split("&")) {
            String[] pair = param.split("=");
            if (pair.length > 1) {
                result.put(pair[0], pair[1]);
            }
        }
        return result;
    }
}